package com.java.zhuiyun.api.SysUser.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.java.zhuiyun.annotation.OptLog;
import com.java.zhuiyun.api.sysmenu.service.IMenuService;
import com.java.zhuiyun.api.SysUser.common.Constants;
import com.java.zhuiyun.api.SysUser.common.Result;
import com.java.zhuiyun.api.SysUser.controller.dto.UserDTO;
import com.java.zhuiyun.api.SysUser.entity.Password;
import com.java.zhuiyun.api.SysUser.entity.SysUser;
import com.java.zhuiyun.api.SysUser.mapper.SysUserMapper;
import com.java.zhuiyun.api.SysUser.service.ISysUserService;
import com.java.zhuiyun.common.response.CommonConstants;
import com.java.zhuiyun.common.response.CommonResult;
import com.java.zhuiyun.util.pageUtil.PageRequest;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.util.List;

/**
 * @ClassName SysUserController
 * @Description TODO 用户管理 用于系统的登录 以及用户的个人信息
 * @Author xy
 * @Date 2023/8/14 20:01
 **/
@RestController
@Api(tags = "用户管理")
@RequestMapping("/User")
@Slf4j
public class SysUserController {

    @Autowired
    ISysUserService sysUserService;

    @Resource
    SysUserMapper sysUserMapper;

    @Resource
    IMenuService menuService;

    /**
    * @Author xy
    * @Description todo 用户管理的全查 （后台管理）
    * @Date 2023/8/15 18:50
    * @Return CommonResult 返回类型
    * @param sysUser 用户实体类
    * @param pageRequest 分页实体类
    */
    @GetMapping("/SysUserList")
    @ApiOperation(value = "用户管理的全查")
    @OptLog(modular = "用户管理", type = CommonConstants.SELECT, describe = "全查")
    public CommonResult userList(SysUser sysUser, PageRequest pageRequest){
        return CommonResult.ok(sysUserService.userList(sysUser,pageRequest));
    }

    /**
    * @Author xy
    * @Description todo 用户管理的添加 （后台管理）
    * @Date 2023/8/15 20:14
    * @Return CommonResult 返回类型
    * @param sysUser 用户实体类
    * @param file 头像
    */
    @PostMapping("/SysUserAdd")
    @ApiOperation(value = "用户管理的添加")
    @OptLog(modular = "用户管理", type = CommonConstants.ADD, describe = "添加")
    public CommonResult SysDictAdd( SysUser sysUser, MultipartFile file){
        int i = sysUserService.SysUserAdd(sysUser,file);
        if (i>0){
            return CommonResult.ok("恭喜您，添加成功");
        }else {
            return CommonResult.error("很抱歉，添加失败");
        }
    }

    /**
     * @Author xy
     * @Description todo 用户管理的修改 （后台管理）
     * @Date 2023/8/15 16:26
     * @Return CommonResult 返回类型
     * @param sysUser 用户实体类
     * @param file 头像
     */
    @PostMapping("/SysUserUpdate")
    @ApiOperation(value = "用户管理的修改")
    @OptLog(modular = "用户管理", type = CommonConstants.UPDATE, describe = "修改")
    public CommonResult SysUserUpdate(SysUser sysUser, MultipartFile file){
        int i = sysUserService.SysUserUpdate(sysUser,file);
        if (i>0){
            return CommonResult.ok("恭喜您，修改成功");
        }else {
            return CommonResult.error("很抱歉，修改失败");
        }
    }

    /**
    * @Author xy
    * @Description todo 用户管理的修改 （后台管理）
    * @Date 2023/10/12 13:50
    * @Return CommonResult 返回类型
    * @param sysUser 用户实体类
    */
    @PostMapping("/updatescope")
    @ApiOperation(value = "用户管理的修改")
    @OptLog(modular = "用户管理", type = CommonConstants.UPDATE, describe = "修改")
    public CommonResult updatescope(@RequestBody SysUser sysUser) {
        sysUserService.updatescope(sysUser);
        return CommonResult.ok("禁用成功");
    }

    /**
    * @Author xy
    * @Description todo 用户管理的删除 （后台管理）
    * @Date 2023/10/12 13:51
    * @Return CommonResult 返回类型
    * @param id 用户id
    */
    @DeleteMapping("/SysUserDelete")
    @ApiOperation(value = "用户管理的删除")
    @OptLog(modular = "用户管理", type = CommonConstants.DELETE, describe = "删除")
    public CommonResult SysUserDelete(Integer id){
        int i = sysUserService.SysUserDelete(id);
        if (i>0){
            return CommonResult.ok("恭喜您，删除成功");
        }else {
            return CommonResult.error("很抱歉，删除失败");
        }
    }

    /**
    * @Author xy
    * @Description todo 用户管理的登录 （后台管理）
    * @Date 2023/10/12 13:51
    * @Return CommonResult 返回类型
    * @param userDTO 用户实体类
    */
    @PostMapping("/login")
    @ApiOperation(value = "用户管理的登录")
    @OptLog(modular = "用户管理", type = CommonConstants.SELECT, describe = "登录")
    public Result login(@RequestBody UserDTO userDTO){
        String userName = userDTO.getUserName();
        String password = userDTO.getPassword();
        //判断用户名和密码是否为空
        if (StringUtils.isBlank(userName) || StringUtils.isBlank(password)){
            return Result.error(Constants.CODE_400,"参数错误");
        }
        UserDTO dto = sysUserService.login(userDTO);
        return Result.success(dto);
    }

    /**
    * @Author xy
    * @Description todo 根据用户名获取数据库表的所有用户属性 （后台管理）
    * @Date 2023/10/12 13:52
    * @Return CommonResult 返回类型
    * @param userName 用户名
    */
    @GetMapping("/userName/{userName}")
    @ApiOperation(value = "根据用户名获取数据库表的所有用户属性")
    @OptLog(modular = "用户管理", type = CommonConstants.SELECT, describe = "根据用户名获取数据库表的所有用户属性")
    public CommonResult findByUsername(@PathVariable String userName){
        SysUser sysUserBack1 = sysUserMapper.selectList(userName);
        return CommonResult.ok(sysUserBack1);
    }

    /**
    * @Author xy
    * @Description todo 根据角色获取数据库表的所有用户属性 （后台管理）
    * @Date 2023/10/12 13:52
    * @Return CommonResult 返回类型
    * @param role 角色
    */
    @GetMapping("/role/{role}")
    @ApiOperation(value = "根据角色获取数据库表的所有用户属性")
    @OptLog(modular = "用户管理", type = CommonConstants.SELECT, describe = "根据角色获取数据库表的所有用户属性")
    public CommonResult findUsersByRole(@PathVariable String role){
        QueryWrapper<SysUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("role",role);
        List<SysUser> list = sysUserService.list(queryWrapper);
        return CommonResult.ok(list);
    }

    /**
    * @Author xy
    * @Description todo 获取当前用户的菜单列表 （后台管理）
    * @Date 2023/10/12 13:53
    * @Return CommonResult 返回类型
    */
    @GetMapping("/MenuList")
    @ApiOperation(value = "获取当前用户的菜单列表")
    @OptLog(modular = "用户管理", type = CommonConstants.SELECT, describe = "获取当前用户的菜单列表")
    public CommonResult MenuList(){
        return CommonResult.ok(menuService.MenuList());
    }

    /**
    * @Author xy
    * @Description todo 根据id获取用户信息 （后台管理）
    * @Date 2023/10/12 13:53
    * @Return CommonResult 返回类型
    * @param id 用户id
    */
    @GetMapping("/selectById")
    @ApiOperation(value = "根据id获取用户信息")
    @OptLog(modular = "用户管理", type = CommonConstants.SELECT, describe = "根据id获取用户信息")
    public CommonResult selectById(Integer id){
        return CommonResult.ok(sysUserMapper.selectById(id));
    }

    /**
    * @Author xy
    * @Description todo 添加用户密码 （后台管理）
    * @Date 2023/10/12 13:54
    * @Return CommonResult 返回类型
    * @param password 用户密码
    */
    @PostMapping("/savePassword")
    @ApiOperation(value = "添加用户密码")
    @OptLog(modular = "用户管理", type = CommonConstants.ADD, describe = "添加用户密码")
    public CommonResult savePassword(@RequestBody Password password){
        return sysUserService.savePassword(password);
    }
}
